import { Modal, message } from 'ant-design-vue';
import { router } from '@/router';
import { useUserStore } from '@/store/modules/user';

/**
 * 权限错误类型
 */
export enum PermissionErrorType {
  /** 未登录 */
  UNAUTHORIZED = 'unauthorized',
  /** 权限不足 */
  FORBIDDEN = 'forbidden',
  /** 登录过期 */
  TOKEN_EXPIRED = 'token_expired',
  /** 账号被禁用 */
  ACCOUNT_DISABLED = 'account_disabled',
}

/**
 * 权限错误信息
 */
interface PermissionErrorInfo {
  type: PermissionErrorType;
  message: string;
  needReLogin: boolean;
  showLoginButton: boolean;
}

/**
 * 权限错误防抖管理器
 */
class PermissionErrorDebouncer {
  private static instance: PermissionErrorDebouncer;
  private lastErrorTime: number = 0;
  private lastErrorType: PermissionErrorType | null = null;
  private readonly debounceTime: number = 3000; // 3秒内相同类型错误只显示一次
  private currentModal: any = null; // 当前显示的Modal实例

  static getInstance(): PermissionErrorDebouncer {
    if (!PermissionErrorDebouncer.instance) {
      PermissionErrorDebouncer.instance = new PermissionErrorDebouncer();
    }
    return PermissionErrorDebouncer.instance;
  }

  /**
   * 检查是否应该显示错误提示
   * @param errorType 错误类型
   * @returns 是否应该显示
   */
  shouldShowError(errorType: PermissionErrorType): boolean {
    const now = Date.now();
    
    // 如果当前有Modal在显示，且是相同类型的错误，不显示新的
    if (this.currentModal && this.lastErrorType === errorType) {
      return false;
    }
    
    // 如果距离上次显示相同类型错误的时间小于防抖时间，不显示
    if (this.lastErrorType === errorType && (now - this.lastErrorTime) < this.debounceTime) {
      return false;
    }
    
    this.lastErrorTime = now;
    this.lastErrorType = errorType;
    return true;
  }

  /**
   * 设置当前Modal实例
   * @param modal Modal实例
   */
  setCurrentModal(modal: any) {
    this.currentModal = modal;
  }

  /**
   * 清除当前Modal实例
   */
  clearCurrentModal() {
    this.currentModal = null;
  }

  /**
   * 重置防抖状态
   */
  reset() {
    this.lastErrorTime = 0;
    this.lastErrorType = null;
    this.currentModal = null;
  }

  /**
   * 关闭当前Modal
   */
  closeCurrentModal() {
    if (this.currentModal) {
      this.currentModal.destroy();
      this.clearCurrentModal();
    }
  }
}

/**
 * 分析权限错误类型
 * @param error 错误对象
 * @returns 权限错误信息
 */
function analyzePermissionError(error: any): PermissionErrorInfo | null {
  const httpStatus = error?.response?.status;
  const businessCode = error?.code;
  const errorMessage = error?.response?.data?.message || error?.message || '';
  
  // HTTP 401 - 未授权/登录过期
  if (httpStatus === 401) {
    return {
      type: PermissionErrorType.UNAUTHORIZED,
      message: errorMessage || '登录已过期，请重新登录',
      needReLogin: true,
      showLoginButton: true,
    };
  }
  
  // HTTP 403 - 权限不足
  if (httpStatus === 403) {
    return {
      type: PermissionErrorType.FORBIDDEN,
      message: errorMessage || '您没有权限执行此操作',
      needReLogin: false,
      showLoginButton: false,
    };
  }
  
  // 业务错误码 1101, 1105 - 登录过期
  if ([1101, 1105].includes(businessCode)) {
    return {
      type: PermissionErrorType.TOKEN_EXPIRED,
      message: errorMessage || '登录已过期，请重新登录',
      needReLogin: true,
      showLoginButton: true,
    };
  }
  
  // 根据错误消息判断
  if (errorMessage) {
    const lowerMessage = errorMessage.toLowerCase();
    
    // 登录相关错误
    if (lowerMessage.includes('登录') || 
        lowerMessage.includes('token') || 
        lowerMessage.includes('unauthorized') ||
        lowerMessage.includes('expired')) {
      return {
        type: PermissionErrorType.TOKEN_EXPIRED,
        message: errorMessage,
        needReLogin: true,
        showLoginButton: true,
      };
    }
    
    // 账号被禁用
    if (lowerMessage.includes('禁用') || 
        lowerMessage.includes('disabled') ||
        lowerMessage.includes('blocked')) {
      return {
        type: PermissionErrorType.ACCOUNT_DISABLED,
        message: errorMessage,
        needReLogin: false,
        showLoginButton: false,
      };
    }
    
    // 权限不足
    if (lowerMessage.includes('权限') || 
        lowerMessage.includes('permission') || 
        lowerMessage.includes('forbidden') ||
        lowerMessage.includes('access denied')) {
      return {
        type: PermissionErrorType.FORBIDDEN,
        message: errorMessage,
        needReLogin: false,
        showLoginButton: false,
      };
    }
  }
  
  return null;
}

/**
 * 显示权限错误提示
 * @param errorInfo 权限错误信息
 */
function showPermissionErrorDialog(errorInfo: PermissionErrorInfo) {
  const { type, message, needReLogin, showLoginButton } = errorInfo;
  const debouncer = PermissionErrorDebouncer.getInstance();
  
  // 检查是否应该显示错误提示（防抖处理）
  if (!debouncer.shouldShowError(type)) {
    return;
  }
  
  // 根据错误类型设置不同的标题和图标
  const getModalConfig = () => {
    switch (type) {
      case PermissionErrorType.UNAUTHORIZED:
      case PermissionErrorType.TOKEN_EXPIRED:
        return {
          title: '登录过期',
          icon: '🔐',
          type: 'warning' as const,
        };
      case PermissionErrorType.ACCOUNT_DISABLED:
        return {
          title: '账号异常',
          icon: '⚠️',
          type: 'error' as const,
        };
      case PermissionErrorType.FORBIDDEN:
      default:
        return {
          title: '权限不足',
          icon: '🚫',
          type: 'warning' as const,
        };
    }
  };
  
  const modalConfig = getModalConfig();
  
  if (showLoginButton) {
    const modal = Modal.confirm({
      title: modalConfig.title,
      content: `${modalConfig.icon} ${message}`,
      okText: '重新登录',
      cancelText: '取消',
      centered: true,
      onOk: () => {
        debouncer.clearCurrentModal();
        handleReLogin();
      },
      onCancel: () => {
        debouncer.clearCurrentModal();
        // 可以在这里添加取消后的处理逻辑
      },
    });
    debouncer.setCurrentModal(modal);
  } else {
    const modal = Modal[modalConfig.type]({
      title: modalConfig.title,
      content: `${modalConfig.icon} ${message}`,
      okText: '我知道了',
      centered: true,
      onOk: () => {
        debouncer.clearCurrentModal();
      },
    });
    debouncer.setCurrentModal(modal);
  }
}

/**
 * 处理重新登录
 */
function handleReLogin() {
  const userStore = useUserStore();
  
  // 清除登录状态
  userStore.clearLoginStatus();
  
  // 重置权限错误防抖状态
  resetPermissionErrorDebounce();
  
  // 显示登录提示
  message.info('正在跳转到登录页面...');
  
  // 延迟跳转，让用户看到提示信息
  setTimeout(() => {
    // 保存当前路由，登录后可以跳转回来
    const currentRoute = router.currentRoute.value;
    const redirectPath = currentRoute.path !== '/login' ? currentRoute.fullPath : '/';
    
    router.push({
      path: '/login',
      query: {
        redirect: redirectPath,
      },
    });
  }, 1000);
}

/**
 * 显示权限不足的提示（向后兼容）
 * @param message 错误消息
 */
export function showPermissionError(message?: string) {
  const debouncer = PermissionErrorDebouncer.getInstance();
  
  // 检查是否应该显示错误提示（防抖处理）
  if (!debouncer.shouldShowError(PermissionErrorType.FORBIDDEN)) {
    return;
  }
  
  const modal = Modal.warning({
    title: '权限不足',
    content: `🚫 ${message || '您没有权限执行此操作'}`,
    okText: '我知道了',
    centered: true,
    onOk: () => {
      debouncer.clearCurrentModal();
    },
  });
  debouncer.setCurrentModal(modal);
}

/**
 * 判断是否为权限相关错误
 * @param error 错误对象
 * @returns 是否为权限错误
 */
export function isPermissionError(error: any): boolean {
  return analyzePermissionError(error) !== null;
}

/**
 * 处理权限错误
 * @param error 错误对象
 * @returns 是否已处理
 */
export function handlePermissionError(error: any): boolean {
  // 检查是否已经处理过，避免重复处理
  if ((error as any)?.__permissionHandled) {
    return true;
  }
  
  const errorInfo = analyzePermissionError(error);
  
  if (errorInfo) {
    // 标记已处理，避免重复处理
    (error as any).__permissionHandled = true;
    
    // 记录权限错误日志（可选）
    console.warn('权限错误:', {
      type: errorInfo.type,
      message: errorInfo.message,
      error: error,
      timestamp: new Date().toISOString(),
    });
    
    // 显示用户友好的错误提示
    showPermissionErrorDialog(errorInfo);
    
    return true;
  }
  
  return false;
}

/**
 * 全局权限错误处理器
 * 可以在路由守卫或全局错误处理中使用
 */
export function setupGlobalPermissionErrorHandler() {
  // 监听未捕获的Promise错误
  window.addEventListener('unhandledrejection', (event) => {
    // 检查是否已经处理过权限错误，避免重复处理
    if (!(event.reason as any)?.__permissionHandled && handlePermissionError(event.reason)) {
      event.preventDefault(); // 阻止默认的错误处理
    }
  });
}

/**
 * 检查用户权限
 * @param permission 权限标识
 * @returns 是否有权限
 */
export function hasPermission(permission: string): boolean {
  const userStore = useUserStore();
  const userPermissions = userStore.perms || [];
  
  return userPermissions.includes(permission) || userPermissions.includes('*');
}

/**
 * 权限装饰器 - 用于方法权限检查
 * @param permission 权限标识
 * @returns 装饰器函数
 */
export function requirePermission(permission: string) {
  return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
    const method = descriptor.value;
    
    descriptor.value = function (...args: any[]) {
      if (!hasPermission(permission)) {
        showPermissionError(`执行此操作需要 "${permission}" 权限`);
        return;
      }
      
      return method.apply(this, args);
    };
  };
}

/**
 * 重置权限错误防抖状态
 * 可以在用户重新登录后调用，确保权限错误提示正常显示
 */
export function resetPermissionErrorDebounce() {
  const debouncer = PermissionErrorDebouncer.getInstance();
  debouncer.reset();
}

/**
 * 手动关闭当前权限错误提示
 * 可以在特定场景下调用，比如用户手动刷新页面时
 */
export function closeCurrentPermissionError() {
  const debouncer = PermissionErrorDebouncer.getInstance();
  debouncer.closeCurrentModal();
}

/**
 * 使用示例：
 * 
 * // 1. 在组件中手动处理权限错误
 * import { handlePermissionError } from '@/utils/permission';
 * 
 * try {
 *   await Api.someProtectedAction();
 * } catch (error) {
 *   if (!handlePermissionError(error)) {
 *     // 如果不是权限错误，进行其他错误处理
 *     console.error('其他错误:', error);
 *   }
 * }
 * 
 * // 2. 检查权限
 * import { hasPermission } from '@/utils/permission';
 * 
 * if (hasPermission('user:delete')) {
 *   // 有权限，显示删除按钮
 * }
 * 
 * // 3. 使用权限装饰器
 * import { requirePermission } from '@/utils/permission';
 * 
 * class UserService {
 *   @requirePermission('user:delete')
 *   deleteUser(id: string) {
 *     // 删除用户逻辑
 *   }
 * }
 * 
 * // 4. 在main.ts中设置全局权限错误处理
 * import { setupGlobalPermissionErrorHandler } from '@/utils/permission';
 * 
 * setupGlobalPermissionErrorHandler();
 * 
 * // 5. 防抖功能使用
 * import { resetPermissionErrorDebounce, closeCurrentPermissionError } from '@/utils/permission';
 * 
 * // 在用户重新登录成功后重置防抖状态
 * resetPermissionErrorDebounce();
 * 
 * // 在特定场景下手动关闭权限错误提示
 * closeCurrentPermissionError();
 */ 